// 路径模块中文封装
const path = require('path');
const process = require('process');

/**
 * 获取路径的绝对路径
 * @param {...string} 路径片段 - 要解析的路径片段
 * @returns {string} 绝对路径
 */
function 获取绝对路径(...路径片段) {
  return path.resolve(...路径片段);
}

/**
 * 连接路径片段
 * @param {...string} 路径片段 - 要连接的路径片段
 * @returns {string} 连接后的路径
 */
function 连接路径(...路径片段) {
  return path.join(...路径片段);
}

/**
 * 获取路径的目录名
 * @param {string} 路径 - 文件或目录的路径
 * @returns {string} 目录名
 */
function 获取目录名(路径) {
  return path.dirname(路径);
}

/**
 * 获取路径的文件名
 * @param {string} 路径 - 文件的路径
 * @param {string} 扩展名 - 可选，要移除的扩展名
 * @returns {string} 文件名
 */
function 获取文件名(路径, 扩展名) {
  return path.basename(路径, 扩展名);
}

/**
 * 获取路径的扩展名
 * @param {string} 路径 - 文件的路径
 * @returns {string} 扩展名（包含点号）
 */
function 获取扩展名(路径) {
  return path.extname(路径);
}

/**
 * 判断是否为绝对路径
 * @param {string} 路径 - 要判断的路径
 * @returns {boolean} 是否为绝对路径
 */
function 是绝对路径(路径) {
  return path.isAbsolute(路径);
}

/**
 * 规范化路径
 * @param {string} 路径 - 要规范化的路径
 * @returns {string} 规范化后的路径
 */
function 规范化路径(路径) {
  return path.normalize(路径);
}

/**
 * 计算相对路径
 * @param {string} 从路径 - 起始路径
 * @param {string} 到路径 - 目标路径
 * @returns {string} 相对路径
 */
function 相对路径(从路径, 到路径) {
  return path.relative(从路径, 到路径);
}

/**
 * 解析路径对象
 * @param {string} 路径 - 要解析的路径
 * @returns {Object} 包含路径各部分的对象
 */
function 解析路径(路径) {
  return path.parse(路径);
}

/**
 * 从对象格式化路径字符串
 * @param {Object} 路径对象 - 包含路径各部分的对象
 * @returns {string} 格式化后的路径字符串
 */
function 格式化路径(路径对象) {
  return path.format(路径对象);
}

/**
 * 获取平台特定的路径分隔符
 * @returns {string} 路径分隔符（Windows为';'，Unix为':'）
 */
function 获取路径分隔符() {
  return path.delimiter;
}

/**
 * 获取平台特定的目录分隔符
 * @returns {string} 目录分隔符（Windows为'\'，Unix为'/'）
 */
function 获取目录分隔符() {
  return path.sep;
}

/**
 * 获取平台特定的文件系统根目录
 * @param {string} 路径 - 可选的路径字符串
 * @returns {string} 根目录路径
 */
function 获取根目录(路径 = process.cwd()) {
  return path.parse(路径).root;
}

module.exports = {
  获取绝对路径,
  连接路径,
  获取目录名,
  获取文件名,
  获取扩展名,
  是绝对路径,
  规范化路径,
  相对路径,
  解析路径,
  格式化路径,
  获取路径分隔符,
  获取目录分隔符,
  获取根目录
};